#include "messagehandler.h"
#include "tcpserver_session.h"
#include "tcp_message.hpp"
#include <iostream>
#include "loghelper.h"
#include "message_types_res.h"
#include "json_message_processor.h"
#include "utility.hpp"

#include <boost/thread/thread.hpp>

using namespace cv;
using namespace std;
using namespace RockLog;
using namespace boost::property_tree;
using namespace boost::asio::ip;

static JsonMessageProcessor s_jsonMessageProcessor;

MessageHandler::MessageHandler(const MessageType_t &messageTypes, TcpServerSession* session)
	: _messageTypes(messageTypes),
	_session(session)
{
}

void MessageHandler::start()
{
}



void MessageHandler::readHeader(const TcpMessage& msg)
{
	if (_messageTypes[kHeartReq] == msg.msgType)
	{
		LOG(kDebug) << "_messageTypes: " << kHeartReq << std::endl;
	}
	else if (_messageTypes[kLoginReq] == msg.msgType)
	{
		LOG(kDebug) << "_messageTypes: " << kLoginReq << std::endl;
	}
	else if (_messageTypes[kLogoutReq] == msg.msgType)
	{
		LOG(kDebug) << "_messageTypes: " << kLogoutReq << std::endl;
	}
	else if (_messageTypes[kFrameReq] == msg.msgType)
	{
		LOG(kDebug) << "_messageTypes: " << kLogoutReq << std::endl;
	}


}

void MessageHandler::readBody(const TcpMessage& msg)
{
	LOG(kDebug) << "_session: " << _session << std::endl
		<< "msg.msgType: " << msg.msgType << std::endl
		<< "msg.body: " << msg.body << std::endl;

	if (_messageTypes[kHeartReq] == msg.msgType)
	{
		onHeartReq(msg);
	}
	else if (_messageTypes[kLoginReq] == msg.msgType) 
	{
		onLoginReq(msg);
	}
	else if (_messageTypes[kLogoutReq] == msg.msgType) 
	{
		onLogoutReq(msg);
	}
}

void MessageHandler::onHeartReq(const TcpMessage& msg)
{
	TcpMessage m;
	m.syncBytes = msg.syncBytes;

	HeartbeatRsp_t rsp;
	rsp.code = 1000;
	m.body = s_jsonMessageProcessor.encodeHeartbeatRsp(rsp);

	m.msgType = _messageTypes[kHeartRsp];
	_session->write(m);
}

void MessageHandler::sendLoginRsp(const LoginRsp_t& rsp)
{
	TcpMessage m;
	m.body = s_jsonMessageProcessor.encodeLoginRsp(rsp);
	m.msgType = _messageTypes[kLoginRsp];
	_session->write(m);
}

void MessageHandler::sendLogoutRsp(const LogoutRsp_t& rsp)
{
	TcpMessage m;
	m.body = s_jsonMessageProcessor.encodeLogoutRsp(rsp);
	m.msgType = _messageTypes[kLogoutRsp];
	_session->write(m);
}

void MessageHandler::sendPicRsp(const FrameNtf_t& rsp)
{
	TcpMessage m;
	int dataSize = rsp.data.total() * rsp.data.elemSize();
	std::vector<char> vec(dataSize);
	memcpy(&vec[0], reinterpret_cast<char *>(rsp.data.data), dataSize);
	std::string str(vec.begin(), vec.end());
	m.binaryData = str;
	m.msgType = _messageTypes[kFrameNtf];
	_session->write(m);
}


void MessageHandler::onLoginReq(const TcpMessage& msg)
{
	LoginRsp_t rsp;
	LoginReq_t req;

	LOG(kDebug) << "receive login req" << std::endl;


	bool ret = s_jsonMessageProcessor.decodeLoginReq(msg.body, req);
	if (!ret)
	{
		rsp.code = CODE_MSG_RESOLVE_FAIL;
		rsp.message = "Fail to resolve the login_req";
		LOG(kErr) << rsp.message << std::endl;
		
		sendLoginRsp(rsp);
		return;
	}

	rsp.code = CODE_SUCCESS;
	sendLoginRsp(rsp);
}

void MessageHandler::onLogoutReq(const TcpMessage& msg)
{
	LogoutRsp_t rsp;

	LOG(kDebug) << "receive logout req" << std::endl;

	rsp.code = CODE_SUCCESS;
	sendLogoutRsp(rsp);
	return;
}

